/**
 * 网络请求
 * @param {Object} options 请求配置
 * @param {String} url 接口地址
 * @param {Object} data 请求的参数
 * @param {Object} header 请求头
 * @param {String} method 请求方式
 * @param {Number} timeout 超时时间，单位 ms
 * @param {String} dataType 如果设为 json，会对返回的数据进行一次 JSON.parse，非 json 不会进行 JSON.parse	
 * @param {String} responseType 设置响应的数据类型。合法值：text、arraybuffer
 */
function request(options = {}) {
	let token = uni.getStorageSync('tokenInfo');
	if(!token){
		token={}
	}
	let req = {};
	req.dataType = options.dataType || 'json';
	req.responseType = options.responseType || 'text';
	req.url = options.url || '';
	options.baseUrl = options.baseUrl || '';
	req.data = options.data || {};
	req.method = options.method || 'GET';
	req.header = Object.assign({
		'content-type': 'application/json',
		'Authorization': token.tokenKey + ' ' + token.token,
		'X-Authorization': token.tokenKey + ' ' + token.refreshToken
	}, options.header);
	if (req.url.indexOf('http://') < 0 && req.url.indexOf('https://') < 0) {
		if (req.url.indexOf('/') != 0) {
			req.url = `/${req.url}`;
		}
		if (options.baseUrl.lastIndexOf('/') === options.baseUrl.length - 1) {
			options.baseUrl = options.baseUrl.substr(0, options.baseUrl.length - 1);
		}
		req.url = `${options.baseUrl}${req.url}`;
	}
	// 检查请求拦截
	if (options.interceptor.request && typeof options.interceptor.request === 'function') {
		let tmpConfig = {};
		req = options.interceptor.request(req);
		if (req === false) {
			return new Promise((resolve, reject) => {
				reject(new Error('请求已被拦截！'));
			});
		}
	}

	return new Promise((resolve, reject) => {
		uni.request({
			...req,
			success: (res) => {
				
				// 读取响应头的token和refreshToken，重新$access.login 
				      const accessToken = res.header['access-token'];
				      const xAccessToken = res.header['x-access-token'];
				
				      if (accessToken !== null && accessToken !== '' && accessToken !== undefined &&
				        xAccessToken !== null && xAccessToken !== '' && xAccessToken !== undefined) {
				        let accessData = uni.getStorageSync('tokenInfo');
						
				        accessData.token = accessToken;
				        accessData.refreshToken = xAccessToken;
				        uni.setStorageSync('tokenInfo',accessData);
				      }
				
				
			
				if (options.interceptor.response && typeof options.interceptor.response ===
					'function') {
					let resInterceptors = options.interceptor.response(res);
			
					// 如果拦截器不返回false，就将拦截器返回的内容给then回调
					if (resInterceptors !== false && resInterceptors.data) {
						resolve(resInterceptors.data);
					} else {
						// 如果拦截器返回false，意味着拦截器定义者认为返回有问题，直接接入catch回调
						reject(new Error("响应数据已被拦截！"));
					}
				} else {
					// 没有拦截器，返回最原始的数据
					resolve(res);
				}
			},
			fail: (err) => {
				// reject(err);
				reject(new Error(err.errMsg || '网络未知错误！'));
			},
			complete: options.complete || function() {}
		});
	});
}

/**
 * Get请求
 * @param {Object} options 
 * @param {String} url 接口地址
 * @param {Object} data 请求数据
 */
function get(options, url, data) {
	options.method = 'GET';
	options.url = url;
	options.data = data;
	return request(options);
}

/**
 * Post请求
 * @param {Object} options
 * @param {String} url 接口地址
 * @param {Object} data 请求数据
 */
function post(options, url, data) {
	options.method = 'POST';
	options.url = url;
	options.data = data;
	return request(options);
}

export default {
	request: request,
	get: get,
	post: post,
}